  
--------------------------------
format的用法
格式化字符串就是统一规格去输出一个字符串
format:两种位置参数 下标位置 关键字位置
例：
    关键字位置
        "{A} bbb {c},{d}".format("A ='Z',c = 'x' d= 'c')
        输出得到 Z bbb x c
    下标位置
          "{0} bbb {1},{2}".format('Z','x' ，'c')
          得到 Z bbb x c
format关键字和下标一块使用
但下标位置必须在关键字之前
否则会报错
转意字符
\\
{{}}
\t  aa

：表示格式化符号的开始
'{0：.1f}{1}'format(27.658,'GB')
得到27.7GB
.1f代表四舍五入保留一位小数

格式化符号：%c
        格式化字符以及ASCII码
        a为ASCII码为97 按英文表ASCII码依次                            格式化符号格式
                                                                    '格式化符号'%'字符串'
            %s
            格式化字符串
            %d
            格式化输出整数
            '%d + %d = %d' % (5 + 5 = 10)
            %o
            格式化输出无符号八进制数
----------------------------------------------------------------------------
列表名称[X：X]（会得到一个列表的拷贝）X:X左比值为开头，右比值为结束但列表内不包含右比值的元素
  [1:]则会输出从1开始的所有的列表元素
  [:X]则会输出从0开始到X的所有列表元素                   列表切片
   [:]则会输出所有的列表元素
-----------------------------------------------------------------------------------------------
列表比较
X = [123]
X2 = [234]  
X > X2 得出结果为false 列表比较从第0位开始 只要有一位数比较为true/false 那么整个列表都为true/false
------------------------------------------------------------------------------------------------
3月13日上午
字符串写法 ‘ 内容  ’“ 内容 ” 也可以三引号写 三引号支持回车换行输出
------ 
%格式化输出       print('我的名字为%s' % name   )只需更改name变量
f  格式化输出       print（f'我的的名字为{name}'）
-------
字符串查找
find()查早子串是否包含在这个字符串中 是则返回开始的下标 否则返回-1
myname = 'name'.find（'查找的内容'，查找开始的位置，查找结束的位置）
print(name.find('a',0,4) #2   -即a在myname变量中的弟二位 从0到4之中查找
-------
index字符串查找
用法与find查找相同但如果字符串中不存在查找子串则报错
-------
count查找子串在字符串中出现的次数
用法与find相同 但字符串中不存在查找子串则会返回0不会报错
-------------------------------------------------------------------------
字符串修改
raplace(） 替换子串但不会覆盖原有的字符串    说明字符串是不可变数据类型
myname = ('wang')
new name=myname.replace(w,W)
格式
一个新的变量 ='修改变量.replace('需要修改的子串',‘修改的子串'，修改的次数）
修改次数如果大于子串在字符串中吹出现的次数则修改字符串中所有的子串
----------
split分割字符串
split（）将一个字符串分割 会得到一个列表
new name=myname.split('a')
格式
新的变量 =分割变量。split（‘分割字符’，分割次数）
即split将字符串中分割字符去除，将剩余的子串以列表的形式返回 返回的子串为分割次数+1
-----------
join()连接字符
myname = [w,a,n,g]
newname = '_ '.join(myname)
得出w_a_n_g
格式
新的变量 ='连接字符'#不可以没有.join(需要连接的变量)
--------------------------------------------------------------------------------------------------
字符串大小写转化
capitalize()将字符串中第一个字符转变为大写
用法与上述相同
print（变量.capitalize()）
title() 将字符串每个单词首字母大写
lower()将字符串中的大写转化为小写
upper():将字符串中小写转大写
lstrip():删除字符串左侧空白字符
用法与上修改，连接，分割等相同
---------------------------------------
删除空白字符
lstrip()删除左侧
rstrip()删除右侧
strip()删除两侧
用法与上修改，连接，分割等相同
----------------------------------------
左右对齐
ljust()左对齐
-----------------------------------------------------------------------------------
3月15
元组：元组不可随便插入或者删除 元组关键为' ，' , 2，3，4这样的数据类型为元组
使用方法与列表相同 也可列表切片                              
只支持查找
可以通过下标查找 print(元组[元组内数据的下标])
也可通过index查找 使用方法与字符串相同
        count
len查找元组内数据的数据次数
print(len(查找的元组))
元组内的修改
------
元组内可以修改元组的列表数据
元组修改可以通过切片修改
temp = ('A','B','C')
temp = temp[:2]+('d',)+temp[2:]
得出temp = ('A','B','c','d')

-------------------------------------------------------------------------------------------
3月17日  上课部分
append()#向一个列表里添加元素
#列表名称.（英文句号）append（’你需要添加的内容‘）#只能添加一个元素
extend（）#与appen使用方法一样，extend（['内容需要为一个列表']）
insert()#向列表添加元素可以调整插入的位置
列表名称.insert（0，‘需要添加的内容')#0为插入的位置 且0为开头   
             .remove（'需要删除的列表内的元素’）
del 列表名称['需要删除的元素' ]
                   []如果中括号内没有内容则代表删除整个列表
              .pop()取出列表内最后一位元素，括号内可以指定元素的位置
copy()复制一个列表
新的变量 = 需要复制的变量.copy()
------------------------------------------------------------------------------------------------
列表循环遍历
whille循环
name_list = ['tom','LLL','AAA']
i = 0                0      1       2
while i<len(name_list):
                     prin(name_list[i])
                     i += 1
用法与whille相同  但是循环遍历为依次打印列表中的元素
 其中len为列表中的元素个数
===============================================================、
for遍历循环
for i in name_list:
              print(i)
用法与for循环相同 
================================================================
列表嵌套
name = [['AAA']['BBB']['CCC']]
print(name[0][1])
即print(name[0][1])打印的即是name列表中的第0个列表中的第一个字符串
如果print(name[0])即打印为name列表中的第一个列表 即['AAA']
------------------------------------------------------------------




---------------------------------------------------------------
字典
字典的符号为大括号
数值为键值对形式出现
各个键值之间用逗号隔开
字典不支持下标
字典为可变类型
----------------------
2020/4/17追加
字典
dict1 = {}  
dict.fromkey(1,2,3)
打印dict1
则会返回
没有value值的字典
即  {1：none , 2:none,3:none}
print后为小括号

fromkey用法

dict.fromkey((1,2,3).'这里为1，2，3对应的值只能有一个数据')

会将1，2，3赋予一个后面添加的数据

如果在原有字典内 用fromkey修改原有字典内的数据

则formkey会创建一个新的字典




--------------------------

#有数据字典
{'name':'XX'，'age'= '20','gender':'男'}
#空字典
变量 = {}
变量 = dict()

字典内修改数据
dict1 = {'name':'XX'，'age'= '20','gender':'男'}
dict1 = ['name'] = 'XXX'
print(dict1)
得出替换数据
dict1 = {'name':'XXX'，'age'= '20','gender':'男'}
向字典内修改数据 如果不存在这个键值对 则添加
dict1 = {'name':'XX'，'age'= '20','gender':'男'}
dict1 = ['id'= 110]
dict1 = {'name':'XX'，'age'= '20','gender':'男'，'id = 110'}

字典内删除数据
del
del(dict1)
删除字典
del dict1['name']
则删除字典内对应的元素

 claer
清空字典 并非删除
dict1.clear()
得到一个空的字典


字典内key值查找

dict1 = {'name':'XX'，'age'= '20','gender':'男'}
print(dict1['name'])
得出结果XX
但如果查找的键值对不在字典中 则报错

字典内get查找
dict1.get('name','XX')
如果查找的key值不存在
则返回第二个数值
如果没有第二个数值则返货none


keys()  查找字典内所有的key
可以用来循环和遍历
print(dict1.keys())

values() 查找字典内所有的值

print(dict1.values())

items()
查找字典内所有的key和values并将键值对做为元组返回
dict1.items()

------------------------------------------------------------------

字典遍历key
dict1 = {'name':'XX'，'age'= '20','gender':'男'}
for key  in dict1.key():
                print(key)
得出name age gender

字典遍历value
用法与遍历KEY相等
dict1 = {'name':'XX'，'age'= '20','gender':'男'}
for value  in dict1.value():
                print(value)
得出XX 20 男

字典遍历items
用法与前两个相同
得出('name','XX')
    ('age'，'20')
    ('gender','男')


字典遍历键值对

dict1 = {'name':'XX'，'age'= '20','gender':'男'}
for key value in  dict1.items():
                        print(f'{key}= {value}')
得出 name = XX
     age  = 20
     gender = 男

字典内索引

即print('打印出来的value',字典名称['字典内的key值'])

则会得出
(打印出来的key对应的value)

=========================================================================

集合















==========================================================================
函数

定义函数
def 函数名 (参数)：
     代码1
     代码2
直接调用 函数名()则执行包含的程序语句

def 函数名(#这里为一个数据，如数字或者字符)：
             A = NUM1 + num2
             print(A)
             则得出A的和 
             A = ('name'+ 'l love you ')
             print(A)
             则输出(namel love you )
函数的返回值
return
def A(NUM1,num2):
     retrun(NUM1+num2)
print A(5,6)
则返回5+6的和
并不执行return下方的语句


参数分类
形式参数(parameter)
实际参数(argument)
如：
     def A(name) 中 name为一个形式参数
     而A(xxx) 中 XXX为一个实际参数


函数文档
def A(name):
     '这里的数据为函数文档，不会被调用函数时打印出来'
     B =('name'+'l love you ')
     print(B)
     则会输出B中的内容
查看函数文档
则使用A.__doc__直接调用
然后输出'这里的数据为函数文档，不会被调用函数时打印出来'
------------------------------------------------------
函数参数
def A (name，words):
     print(name+'->'+words)
直接调用A这个函数并给他两个参数
A('XX','XXXXXXXX')
就会得出XX->XXXXXXXX

如过参数位置出错那么会和想要输出的内容不相同
但是可以通过参数的赋值 如A(name ='XXX',words = 'XXXXXXXX')
来保证参数出错时位置不发生改变


默认参数
默认参数可以通过定义函数时就给参数添加一个默认数值
如 def A(name = 'XXX'，words = 'XXXXXXXX')
那么在调用函数的同时没有给这个函数一个参数
也不会报错
则会打印默认的参数
如果在调用函数再赋予参数
则会替换掉原先的参数再进行输出


收集参数
def test(*params)
     print('参数的长度是：'，len(params));
     print('弟二个参数是：'，params[1]);

调用test时 *号作为收集参数符号 只会收集给出参数中需要的
test(1,'XXX'，5，6，7，8)
则会返回
'参数的长度是5'
'第二个参数是XXX'

pytho中
过程(procedure)是简单的 特殊且没有返回值的
函数(function)是特殊的 是有返回值的
且如果将一个函数赋值于一个变量中
打印这个变量则会返回 none
也说明函数是一定会有返回值的

python中存在局部变量与全局变量
local variable 局部变量
Global variable 全局变量

def discounts(price，rate):
          final_price = price *rate    中price rate final_price 在这个函数中属于局部变量
                                        在下方调用discounts这个函数的时候
                                        如果想要输出final_price 时会报错
                                        python在运行代码的时候利用栈stack进行存储
                                        当执行完一个语句时 该语句会被自动删除
                                        所以在下方想要输出final_price的时候会报错  
           retrun final_price           

old_price = float(input('请输入原价'))
rate = float(input('请输入折扣率'))
new_price = discounts(old_price，rate)   #在执行这条语句时 局部变量finla_price 已经被删除
print('打折后价格是：'，new_price)
print('这里打印局部变量finla_price的值'，finla_price)  #这里会报错 无法访问到finla_price


def discounts(price，rate):
          final_price = price *rate
          old_price = 50
          print('修改后的全局变量的值是：'，old_price)
        #如果在函数内部修改全局变量 则python会新建一个同名的局部变量来代替全局变量


old_price = float(input('请输入原价'))
rate = float(input('请输入折扣率'))
print('修改后的old_price的值是：'，old_price)      #如果在全局变量中打印old_price的值 但是不会发生改变
new_price = discounts(old_price，rate)   
print('打折后价格是：'，new_price)

函数内修改全局变量

Global 修改全局变量
num3 = 1
def myfun ():
     global num3
     num3 = 2
     print(2)

则 myfun()输出结果为2
print(num3)输出结果也为2


-----------------------------------------------------------------------------------------------------------
内置函数







-------------------------------------------------------------------------------------------------------------
函数嵌套
def 定义函数内部可以再定义另一个函数
如
     def myfun():
          print('这是函数1')
                    def myfun1():
                         print('这是函数2')
则 调用myfun时 会先打印'这是函数1'再打印'这是函数2'
在外部调用myfun2时则会报错
--------------------------------------------
闭包

如果在一个内部函数中对一个外部作用域(但不是在一个全局作用域的变量中进行引用)
那么内部函数就会被认为闭包

def funX(X):
     def funY(y):
          return x * y
     return funY

这个函数就为闭包
funY的外部作用域就为funX的整个空间
funX的内部函数就为funY
的变量 (X)进行引用
那么内部函数funY就是一个闭包
-----------------------------------------------
lambda表达式

G =  lambda X : 2 * X + 1 
G(5)
得出11

那么从上面可以发现
lambda表达式不需要定义函数
只需要给一个变量去接收
直接调用变量就可以输出

冒号前的数据可以是多个的


-------------
lambda表达式 中

 bif 

filter()  过滤器

filter(function/none，[true，false，0，1])
           ↑
       可为一个函数或者筛选真假

filter 会过滤掉 列表中任何不为true的内容

list(filter(lambda X : X % 2 ,range(10) ))

则会自动筛选掉 不为真的数

比起定义一个函数来调用 使用lambda表达式更为方便


lambda表达式

*args

lambda表达式中*args接收到的数据会作为一个元组进行返回

G = lambda *agrs: agrs
print(G(参数，))

则会作为元组返回 括号内的参数可以是多个的

**kwargs

**kwargs会作为一个字典返回数据

G  = lambda **kwargs : kwargs
print(G(name = 'python'，age = '19'))

则会作为一个字典进行返回

lambda中带判断

G = lambda a, b : a if a > b else b 
则
a > b 则会返回a的值
反之则会返回b
------------------------------------------------------------
高阶函数

把函数作为另一个函数的参数传入
这样的函数叫高阶函数

高阶函数

abs()  括号内参数的绝对值

round()  四舍五入括号内参数

内置高阶函数

map(函数，列表)

map函数将变量中的函数作用于列表当中

list[1,2,3,4]

def func(X)：
     return x ** 2

result = map (func，list)

print(list(result))

则会将列表内的数字进行二次方输出



-------------------------------------------------------------
递归

递归就是函数内部调用其他函数也可以调用自己

递归在python3中最大深度为100层
可以通过inport sys 表达式来重新定义递归的最大深度
sys.setrecursinlimit(设定的层数)



====================================================================
面向对象

封装：模拟真实世界，将数据和代码都封装在一起

属性 = 对象 + 方法

对象就是变量

方法就是函数


类： class

OO = object Oriented
    面向对象
特征 ： 封装， 继承，多态

多态定义：不同对线对不同方法的相应方式

PS: OOA 面向对象分析 OOP 面向对象编程 OOD 面向对象设计

self方法相当于THIS指针

在定义时将self写入第一个参数

--------------------------------------------
魔法方法

_init_(self)

可以给对象添加参数
如果不添加时，会报错

共有和私有函数

定义私有函数 需要再变量或函数 添加双下划线
如：
     __变量或函数

如果访问私有变量 直接调用会无法输出
 
如果需要调用

则 变量._类名__私有变量名


--------------------------------------------------
继承

class ABC：
          pass

class abcd(ABC)：
          pass

则 abcd会继承ABC中的内容

ABC为父类

abcd为子类

子类定义父类同名的变量或者相同的方法 那么子类会自动覆盖与父类相同的变量或方法

对父类内的变量方法不会产生影响
-------------------------------------------------------------------------

异常

语法错误和异常

异常是指 程序语法结构没有报错但实际运行会出现错误

异常处理：
     try:
          ('可能出现异常的代码')

     except:
          ('出现异常执行的代码')

     finally:
          ('无论存在不存在都会执行的代码')     #可有可无
     try中出现return
     如果后跟finally
     则不会执行return 会读取finally中的return
     


可能出现异常的代码可能出现多个错误

如字符错误 语法错误

所以可用多个except来对应每一个错误

在try中如果出现return就不能使用else

------------------------------------------------------------------

文件操作

open.()函数   打开文件

open()
# open(file: str, mode: str, buffering: int, encoding: str, errors: str, newline: str, closefd: bool, opener: str)
# mode  中参数
''' 
r read 读文件
w write 写文件
r w  只能用于纯文本文件

binary 二进制 字节

r b readbinary 

w b writebinary

rb wb 用二进制文件

'''



-----------------------------------------------------------------------------------------------------------------

列表推导式

列表推导式简化循环遍历列表中的函数定义

格式

[表达式 for 变量 in 旧列表 if 条件] 

后if可以不加

列表推导式同字典推导式和集合推导式一样












     
               
               







                                             